home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / os2 / pvm34b3.zip / pvm34b3 / pvm3 / src / nmdclass.c < prev    next >
C/C++ Source or Header  |  1997-07-22  |  6KB  |  294 lines
  1.  
  2. static char rcsid[] =
  3.     "$Id: nmdclass.c,v 1.3 1997/06/25 22:09:16 pvmsrc Exp $";
  4.  
  5. /*
  6.  *         PVM version 3.4:  Parallel Virtual Machine System
  7.  *               University of Tennessee, Knoxville TN.
  8.  *           Oak Ridge National Laboratory, Oak Ridge TN.
  9.  *                   Emory University, Atlanta GA.
  10.  *      Authors:  J. J. Dongarra, G. E. Fagg, M. Fischer
  11.  *          G. A. Geist, J. A. Kohl, R. J. Manchek, P. Mucci,
  12.  *         P. M. Papadopoulos, S. L. Scott, and V. S. Sunderam
  13.  *                   (C) 1997 All Rights Reserved
  14.  *
  15.  *                              NOTICE
  16.  *
  17.  * Permission to use, copy, modify, and distribute this software and
  18.  * its documentation for any purpose and without fee is hereby granted
  19.  * provided that the above copyright notice appear in all copies and
  20.  * that both the copyright notice and this permission notice appear in
  21.  * supporting documentation.
  22.  *
  23.  * Neither the Institutions (Emory University, Oak Ridge National
  24.  * Laboratory, and University of Tennessee) nor the Authors make any
  25.  * representations about the suitability of this software for any
  26.  * purpose.  This software is provided ``as is'' without express or
  27.  * implied warranty.
  28.  *
  29.  * PVM version 3 was funded in part by the U.S. Department of Energy,
  30.  * the National Science Foundation and the State of Tennessee.
  31.  */
  32.  
  33. /*
  34.  *    nmdclass.c
  35.  *
  36.  *    Name-server database.
  37.  *
  38. $Log: nmdclass.c,v $
  39.  * Revision 1.3  1997/06/25  22:09:16  pvmsrc
  40.  * Markus adds his frigging name to the author list of
  41.  *     every file he ever looked at...
  42.  *
  43.  * Revision 1.2  1997/01/28  19:26:55  pvmsrc
  44.  * New Copyright Notice & Authors.
  45.  *
  46.  * Revision 1.1  1996/09/23  23:44:22  pvmsrc
  47.  * Initial revision
  48.  *
  49.  * Revision 1.2  1994/06/03  20:38:19  manchek
  50.  * version 3.3.0
  51.  *
  52.  * Revision 1.1  1993/08/30  23:26:49  manchek
  53.  * Initial revision
  54.  *
  55.  */
  56.  
  57.  
  58. #include <stdio.h>
  59. #ifdef    SYSVSTR
  60. #include <string.h>
  61. #else
  62. #include <strings.h>
  63. #endif
  64. #include <pvm3.h>
  65. #include "pvmalloc.h"
  66. #include "listmac.h"
  67.  
  68.  
  69. /*
  70. *    one of these for each name (class) in the database
  71. */
  72.  
  73. struct nmdcls {
  74.     struct nmdcls *nc_link;        /* dll of peers */
  75.     struct nmdcls *nc_rlink;
  76.     char *nc_name;                /* class name or 0 if list master */
  77.     struct nmdind *nc_ent;        /* entries in class */
  78. };
  79.  
  80. /*
  81. *    one of these for each index (entry) in the database
  82. */
  83.  
  84. struct nmdind {
  85.     struct nmdind *ni_link;        /* dll of peers */
  86.     struct nmdind *ni_rlink;
  87.     int ni_ind;                    /* index in class or -1 if master */
  88.     int ni_data;                /* value */
  89. };
  90.  
  91.  
  92. /***************
  93.  **  Private  **
  94.  **           **
  95.  ***************/
  96.  
  97. static char pvmtxt[1024];                /* scratch for error log */
  98. static struct nmdcls *classes = 0;        /* the database */
  99.  
  100.  
  101. struct nmdind *
  102. ni_new(ind)
  103.     int ind;
  104. {
  105.     struct nmdind *ep;
  106.  
  107.     if (ep = TALLOC(1, struct nmdind, "nmdi")) {
  108.         ep->ni_link = ep->ni_rlink = ep;
  109.         ep->ni_data = 0;
  110.         ep->ni_ind = ind;
  111.     }
  112.     return ep;
  113. }
  114.  
  115.  
  116. struct nmdcls *
  117. nc_new(name)
  118.     char *name;
  119. {
  120.     struct nmdcls *np;
  121.  
  122.     if (np = TALLOC(1, struct nmdcls, "nmdc")) {
  123.         if (name) {
  124.             np->nc_name = STRALLOC(name);
  125.             np->nc_ent = ni_new(-1);
  126.             LISTPUTBEFORE(classes, np, nc_link, nc_rlink);
  127.  
  128.         } else {
  129.             np->nc_link = np->nc_rlink = np;
  130.             np->nc_name = 0;
  131.             np->nc_ent = 0;
  132.         }
  133.     }
  134.     return np;
  135. }
  136.  
  137.  
  138. struct nmdcls *
  139. nc_find(name)
  140.     char *name;
  141. {
  142.     struct nmdcls *np;
  143.  
  144.     for (np = classes->nc_link; np != classes; np = np->nc_link)
  145.         if (!strcmp(np->nc_name, name))
  146.             return np;
  147.     return (struct nmdcls*)0;
  148. }
  149.  
  150.  
  151. int
  152. nmd_init()
  153. {
  154.     classes = nc_new((char*)0);
  155.     return 0;
  156. }
  157.  
  158.  
  159. int
  160. nmd_insert(name, req, data)
  161.     char *name;
  162.     int req;
  163.     int data;
  164. {
  165.     struct nmdcls *np;
  166.     struct nmdind *ep, *ep2;
  167.  
  168.     if (!(np = nc_find(name)))
  169.         np = nc_new(name);
  170.  
  171.     if (req >= 0) {
  172.         for (ep = np->nc_ent->ni_link; ep != np->nc_ent; ep = ep->ni_link)
  173.             if (ep->ni_ind >= req)
  174.                 break;
  175.         if (ep->ni_ind == req)
  176.             ep = 0;
  177.  
  178.     } else {
  179.         req = 0;
  180.         for (ep = np->nc_ent->ni_link; ep != np->nc_ent; ep = ep->ni_link) {
  181.             if (ep->ni_ind != req)
  182.                 break;
  183.             req = ep->ni_ind + 1;
  184.         }
  185.     }
  186.  
  187.     if (ep) {
  188.         ep2 = ni_new(req);
  189.         ep2->ni_data = data;
  190.         LISTPUTBEFORE(ep, ep2, ni_link, ni_rlink);
  191.  
  192.     } else
  193.         req = -1;
  194.  
  195.     return req;
  196. }
  197.  
  198.  
  199. int
  200. nmd_delete(name, req)
  201.     char *name;
  202.     int req;
  203. {
  204.     struct nmdcls *np;
  205.     struct nmdind *ep = 0;
  206.  
  207.     if (np = nc_find(name)) {
  208.         if (req >= 0) {
  209.             for (ep = np->nc_ent->ni_link; ep != np->nc_ent; ep = ep->ni_link)
  210.                 if (ep->ni_ind == req)
  211.                     break;
  212.             if (ep == np->nc_ent)
  213.                 ep = 0;
  214.         }
  215.     }
  216.  
  217.     if (ep) {
  218.         req = ep->ni_ind;
  219.         LISTDELETE(ep, ni_link, ni_rlink);
  220.         PVM_FREE(ep);
  221.         if (np->nc_ent->ni_link == np->nc_ent) {
  222.             LISTDELETE(np, nc_link, nc_rlink);
  223.             PVM_FREE(np->nc_name);
  224.             PVM_FREE(np->nc_ent);
  225.             PVM_FREE(np);
  226.         }
  227.     } else
  228.         req = -1;
  229.  
  230.     return req;
  231. }
  232.  
  233.  
  234. int
  235. nmd_lookup(name, req, datap)
  236.     char *name;
  237.     int req;
  238.     int *datap;
  239. {
  240.     struct nmdcls *np;
  241.     struct nmdind *ep = 0;
  242.  
  243.     if (np = nc_find(name)) {
  244.         if (req >= 0) {
  245.             for (ep = np->nc_ent->ni_link; ep != np->nc_ent; ep = ep->ni_link)
  246.                 if (ep->ni_ind == req)
  247.                     break;
  248.         } else
  249.             ep = np->nc_ent->ni_link;
  250.  
  251.         if (ep == np->nc_ent)
  252.             ep = 0;
  253.     }
  254.  
  255.     if (ep) {
  256.         req = ep->ni_ind;
  257.         *datap = ep->ni_data;
  258.  
  259.     } else
  260.         req = -1;
  261.  
  262.     return req;
  263. }
  264.  
  265.  
  266. int
  267. nmd_dump(np)
  268.     struct nmdcls *np;
  269. {
  270.     struct nmdind *ep;
  271.  
  272.     sprintf(pvmtxt, "<%s>\n", np->nc_name);
  273.     pvmlogerror(pvmtxt);
  274.     for (ep = np->nc_ent->ni_link; ep != np->nc_ent; ep = ep->ni_link) {
  275.         sprintf(pvmtxt, "%4d: 0x%08x\n", ep->ni_ind, ep->ni_data);
  276.         pvmlogerror(pvmtxt);
  277.     }
  278.     return 0;
  279. }
  280.  
  281.  
  282. int
  283. nmd_dumpall()
  284. {
  285.     struct nmdcls *np;
  286.  
  287.     pvmlogerror("nmd_dumpall():\n");
  288.     for (np = classes->nc_link; np != classes; np = np->nc_link)
  289.         nmd_dump(np);
  290.     return 0;
  291. }
  292.  
  293.  
  294.